const Router = require('koa-router')

const {success} = require('../../lib/helper')


const {encrypt} = require('../../../core/secret')


const {
    RegisterValidator, UpdatePasswordValidator, MainContentValidator, AdminChangeValidator
} = require('../../validators/validator')

const {
    User
} = require('../../models/user')
const {Equipment} = require("../../models/equipment");
const {decrypt} = require("../../../core/secret");
const {Auth} = require("../../../middlewares/auth");

const router = new Router({
    prefix: '/v1/user'
})

//注册 新增数据 put get delete
// 静态

router.post('/register', async (ctx) => {
    const v = await new RegisterValidator().validate(ctx)
    // 令牌获取 颁布令牌
    const user = {
        email: decrypt(v.get('body.email')),
        password: decrypt(v.get('body.password2')),
        nickname: decrypt(v.get('body.nickname')),
        phone: decrypt(v.get('body.phone')),
        idcard: decrypt(v.get('body.idcard')),
        location: decrypt(v.get('body.location')),
        admin: 0,
        logout: 1
    }

    await User.create(user)
    success()
})

// 更新密码（根据email）
router.post('/reset', new Auth(30).m, async (ctx) => {
    const v = await new UpdatePasswordValidator().validate(ctx)

    const {email, newPassword} = v.get('body')

    // 根据email查找用户
    const user = await User.findOne({where: {email}})
    if (!user) {
        success('没找到此邮箱账户，请检查邮箱地址.', 201)
    }

    // 暂时无需验证旧密码，已通过注册邮箱对用户进行了验证

    // 更新密码（这里应该使用加密后的新密码）

    user.password = newPassword; // 实际上应该使用加密函数对新密码进行加密
    await user.save()
    success('Password updated successfully.')
})

// 把用户设为管理员
// 当前用户的id - 判断是否为超级管理员
// 要赋权的用户id - 设置为管理员
// 把用户设为管理员
router.post('/setAdmin', new Auth(30).m, async (ctx) => {
    const v = await new MainContentValidator().validate(ctx);

    const uid = v.get('body.uid');
    const sid = v.get('body.sid');

    // 检查 uid 是否为超级管理员
    const currentUser = await User.findByPk(uid);
    if (!currentUser || currentUser.admin <= 1) {
        success('当前用户没有足够的权限执行此操作', 201)
        return;
    }

    // 设置 sid 为管理员
    await User.update({admin: 1}, {where: {id: sid}});
    success('用户已成功设置为管理员', 200)
});

// 取消用户管理员权限
router.post('/unsetAdmin', new Auth(30).m, async (ctx) => {
    const v = await new MainContentValidator().validate(ctx);

    const uid = v.get('body.uid');
    const sid = v.get('body.sid');

    // 检查 uid 是否为超级管理员
    const currentUser = await User.findByPk(uid);
    if (!currentUser || currentUser.admin <= 1) {
        success('当前用户没有足够的权限执行此操作', 201)
        return;
    }

    // 取消 sid 的管理员权限
    await User.update({admin: 0}, {where: {id: sid}});
    success('用户的管理员权限已成功取消', 200)
});


router.post('/setLogout', new Auth(30).m, async (ctx) => {
    const v = await new MainContentValidator().validate(ctx);

    const uid = v.get('body.uid');
    const sid = v.get('body.sid');

    // 检查 uid 是否为超级管理员
    const currentUser = await User.findByPk(uid);
    if (!currentUser || currentUser.admin <= 1) {
        success('当前用户没有足够的权限执行此操作', 201)
        return;
    }

    // 设置 sid 为管理员
    await User.update({logout: 0}, {where: {id: sid}});
    success('账户已注销', 200)
});

// 取消用户管理员权限
router.post('/unSetLogout', new Auth(30).m, async (ctx) => {
    const v = await new MainContentValidator().validate(ctx);

    const uid = v.get('body.uid');
    const sid = v.get('body.sid');

    // 检查 uid 是否为超级管理员
    const currentUser = await User.findByPk(uid);
    if (!currentUser || currentUser.admin <= 1) {
        success('当前用户没有足够的权限执行此操作', 201)
        return;
    }

    // 取消 sid 的管理员权限
    await User.update({logout: 1}, {where: {id: sid}});
    success('账户已生效', 200)
});


router.get('/list', new Auth(30).m, async ctx => {
    const v = await new MainContentValidator().validate(ctx)
    // email: v.get('body.email'),
    // 从查询字符串中获取分页参数
    const {page = 1, pagesize = 10} = ctx.query;

    // 验证分页参数是否为正整数，并设置合理的默认值
    const validatedPage = Math.max(Number(page) || 1, 1);
    const validatedPagesize = Math.max(Number(pagesize) || 10, 1);

    // 计算偏移量
    const offset = (validatedPage - 1) * validatedPagesize;

    // 使用Sequelize的findAndCountAll方法进行分页查询
    const result = await User.findAndCountAll({
        attributes: ['id', 'nickname', 'email', 'admin', 'phone', 'idcard', 'location', 'logout'],
        limit: validatedPagesize,
        offset: offset,
    });

    // 对每个用户的idcard字段进行加密
    const encryptedUsers = result.rows.map(user => {
        const encryptedUser = JSON.parse(JSON.stringify(user)); // 克隆对象以避免循环引用
        // encryptedUser.id = encrypt(encryptedUser.id); // 对id字段进行加密
        // encryptedUser.nickname = encrypt(encryptedUser.nickname); // 对nickname字段进行加密
        // encryptedUser.email = encrypt(encryptedUser.email); // 对email字段进行加密
        // encryptedUser.admin = encrypt(encryptedUser.admin); // 对admin字段进行加密
        // encryptedUser.phone = encrypt(encryptedUser.phone); // 对phone字段进行加密
        encryptedUser.idcard = encrypt(encryptedUser.idcard); // 对idcard字段进行加密
        // encryptedUser.location = encrypt(encryptedUser.location); // 对location字段进行加密
        // encryptedUser.logout = encrypt(encryptedUser.logout); // 对logout字段进行加密
        return encryptedUser;
    });

    let finResult = {
        data: encryptedUsers,
        total: result.count,
        page: validatedPage,
        pagesize: validatedPagesize,
    }

    success(finResult)
})


module.exports = router
